#pragma once

#include <iostream>
#include <string>
#include <memory>
#include "Epoller.hpp"
#include "Connection.hpp"
#include "Socket.hpp"
#include "Log.hpp"
#include "Reactor.hpp"
#include "Protocol.hpp"
#include "IOService.hpp"
#include "Calculator.hpp"
// 专门负责获取连接的模块, 里面就要包含套接字创建的相关信息
// 连接管理器
using namespace SocketModule;
using namespace LogModule;
class Listener : public Connection
{
public:
    Listener(int port) : _listensocket(std::make_unique<TcpSocket>()), _port(port)
    {
        _listensocket->BuildTcpSocket(_port);
        SetSockfd(_listensocket->Fd());
        SetEvents(EPOLLIN | EPOLLET);
    }
    // 获取新连接, 我们回调到这里，天然就有了父类的Connection
    virtual void Recver()override 
    {
        // 读事件就绪，而且是listensockfd就绪
        // IO 处理---获取新连接
        // 你怎么知道，一次来的，就是一个连接呢？怎么保证一次读完了呢
        while (true)
        {
            InetAddr client_addr;
            int aerrno = 0;
            // accept 非阻塞的时候，就是IO，我们就像处理read一样，处理accept
            int sockfd = _listensocket->Acceptor(&client_addr, &aerrno);
            if (sockfd > 0)
            {
                // 成功了，我们要添加到epoll
                LOG(LogLevel::DEBUG) << "accept success: " << sockfd;
                // 普通的文件描述符，处理IO的，也是Connection
                // 1.sockfd包装成Connection
                auto conn = std::make_shared<IOService>(sockfd);
                conn->RegisterOnMessage(HandlerRequest); //
                // 2.插入到epollServer
                GetOwner()->InsertConnection(conn);
                LOG(LogLevel::DEBUG) << "Add connection success: " << sockfd;
            }
            else
            {
                if (errno == EAGAIN || errno == EWOULDBLOCK)
                {
                    LOG(LogLevel::DEBUG) << "acceptor all connections ... done";
                    break;
                }
                else if (errno == EINTR)
                {
                    LOG(LogLevel::DEBUG) << "acceptor interrupted by signal ... continue";
                    continue;
                }
                else
                {
                    LOG(LogLevel::WARNING) << "acceptor error: ignore";
                    break;
                }
            }
        }
    }
    virtual void Sender() override
    {
    }
    virtual void Excepter() override
    {
    }
    int SockFd()
    {
        return _listensocket->Fd();
    }
    ~Listener()
    {
        _listensocket->Close();
    }

private:
    std::unique_ptr<Socket> _listensocket;
    int _port; // 服务器端口号
};
